/*
  Highlight.js 10.5.0 (af20048d)
  License: BSD-3-Clause
  Copyright (c) 2006-2020, Ivan Sagalaev
*/
var hljs = function () {
    "use strict";

    function e(t) {
        return t instanceof Map ? t.clear = t.delete = t.set = () => {
            throw Error("map is read-only")
        } : t instanceof Set && (t.add = t.clear = t.delete = () => {
            throw Error("set is read-only")
        }), Object.freeze(t), Object.getOwnPropertyNames(t).forEach((n => {
            var s = t[n]
            ;"object" != typeof s || Object.isFrozen(s) || e(s)
        })), t
    }

    var t = e, n = e;
    t.default = n
    ;

    class s {
        constructor(e) {
            void 0 === e.data && (e.data = {}), this.data = e.data
        }

        ignoreMatch() {
            this.ignore = !0
        }
    }

    function r(e) {
        return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;")
    }

    function a(e, ...t) {
        const n = Object.create(null);
        for (const t in e) n[t] = e[t]
        ;
        return t.forEach((e => {
            for (const t in e) n[t] = e[t]
        })), n
    }

    const i = e => !!e.kind
    ;

    class o {
        constructor(e, t) {
            this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this)
        }

        addText(e) {
            this.buffer += r(e)
        }

        openNode(e) {
            if (!i(e)) return;
            let t = e.kind
            ;e.sublanguage || (t = `${this.classPrefix}${t}`), this.span(t)
        }

        closeNode(e) {
            i(e) && (this.buffer += "</span>")
        }

        value() {
            return this.buffer
        }

        span(e) {
            this.buffer += `<span class="${e}">`
        }
    }

    class l {
        constructor() {
            this.rootNode = {
                children: []
            }, this.stack = [this.rootNode]
        }

        get top() {
            return this.stack[this.stack.length - 1]
        }

        get root() {
            return this.rootNode
        }

        add(e) {
            this.top.children.push(e)
        }

        openNode(e) {
            const t = {kind: e, children: []}
            ;this.add(t), this.stack.push(t)
        }

        closeNode() {
            if (this.stack.length > 1) return this.stack.pop()
        }

        closeAllNodes() {
            for (; this.closeNode();) ;
        }

        toJSON() {
            return JSON.stringify(this.rootNode, null, 4)
        }

        walk(e) {
            return this.constructor._walk(e, this.rootNode)
        }

        static _walk(e, t) {
            return "string" == typeof t ? e.addText(t) : t.children && (e.openNode(t),
                t.children.forEach((t => this._walk(e, t))), e.closeNode(t)), e
        }

        static _collapse(e) {
            "string" != typeof e && e.children && (e.children.every((e => "string" == typeof e)) ? e.children = [e.children.join("")] : e.children.forEach((e => {
                l._collapse(e)
            })))
        }
    }

    class c extends l {
        constructor(e) {
            super(), this.options = e
        }

        addKeyword(e, t) {
            "" !== e && (this.openNode(t), this.addText(e), this.closeNode())
        }

        addText(e) {
            "" !== e && this.add(e)
        }

        addSublanguage(e, t) {
            const n = e.root
            ;n.kind = t, n.sublanguage = !0, this.add(n)
        }

        toHTML() {
            return new o(this, this.options).value()
        }

        finalize() {
            return !0
        }
    }

    function u(e) {
        return e ? "string" == typeof e ? e : e.source : null
    }

    const g = "[a-zA-Z]\\w*", d = "[a-zA-Z_]\\w*", h = "\\b\\d+(\\.\\d+)?",
        f = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", p = "\\b(0b[01]+)", m = {
            begin: "\\\\[\\s\\S]", relevance: 0
        }, b = {
            className: "string", begin: "'", end: "'",
            illegal: "\\n", contains: [m]
        }, x = {
            className: "string", begin: '"', end: '"',
            illegal: "\\n", contains: [m]
        }, E = {
            begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
        }, v = (e, t, n = {}) => {
            const s = a({className: "comment", begin: e, end: t, contains: []}, n)
            ;
            return s.contains.push(E), s.contains.push({
                className: "doctag",
                begin: "(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):", relevance: 0
            }), s
        }, N = v("//", "$"), w = v("/\\*", "\\*/"), R = v("#", "$");
    var y = Object.freeze({
        __proto__: null, IDENT_RE: g, UNDERSCORE_IDENT_RE: d, NUMBER_RE: h, C_NUMBER_RE: f,
        BINARY_NUMBER_RE: p,
        RE_STARTERS_RE: "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
        SHEBANG: (e = {}) => {
            const t = /^#![ ]*\//
            ;
            return e.binary && (e.begin = ((...e) => e.map((e => u(e))).join(""))(t, /.*\b/, e.binary, /\b.*/)),
                a({
                    className: "meta", begin: t, end: /$/, relevance: 0, "on:begin": (e, t) => {
                        0 !== e.index && t.ignoreMatch()
                    }
                }, e)
        }, BACKSLASH_ESCAPE: m, APOS_STRING_MODE: b,
        QUOTE_STRING_MODE: x, PHRASAL_WORDS_MODE: E, COMMENT: v, C_LINE_COMMENT_MODE: N,
        C_BLOCK_COMMENT_MODE: w, HASH_COMMENT_MODE: R, NUMBER_MODE: {
            className: "number",
            begin: h, relevance: 0
        }, C_NUMBER_MODE: {className: "number", begin: f, relevance: 0},
        BINARY_NUMBER_MODE: {className: "number", begin: p, relevance: 0}, CSS_NUMBER_MODE: {
            className: "number",
            begin: h + "(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
            relevance: 0
        }, REGEXP_MODE: {
            begin: /(?=\/[^/\n]*\/)/, contains: [{
                className: "regexp",
                begin: /\//, end: /\/[gimuy]*/, illegal: /\n/, contains: [m, {
                    begin: /\[/, end: /\]/,
                    relevance: 0, contains: [m]
                }]
            }]
        }, TITLE_MODE: {
            className: "title", begin: g, relevance: 0
        }, UNDERSCORE_TITLE_MODE: {className: "title", begin: d, relevance: 0}, METHOD_GUARD: {
            begin: "\\.\\s*[a-zA-Z_]\\w*", relevance: 0
        }, END_SAME_AS_BEGIN: e => Object.assign(e, {
            "on:begin": (e, t) => {
                t.data._beginMatch = e[1]
            }, "on:end": (e, t) => {
                t.data._beginMatch !== e[1] && t.ignoreMatch()
            }
        })
    });

    function _(e, t) {
        "." === e.input[e.index - 1] && t.ignoreMatch()
    }

    function k(e, t) {
        t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)",
            e.__beforeBegin = _, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords)
    }

    function M(e, t) {
        Array.isArray(e.illegal) && (e.illegal = ((...e) => "(" + e.map((e => u(e))).join("|") + ")")(...e.illegal))
    }

    function O(e, t) {
        if (e.match) {
            if (e.begin || e.end) throw Error("begin & end are not supported with match")
                ;
            e.begin = e.match, delete e.match
        }
    }

    function A(e, t) {
        void 0 === e.relevance && (e.relevance = 1)
    }

    const L = ["of", "and", "for", "in", "not", "or", "if", "then", "parent", "list", "value"]
    ;

    function B(e, t) {
        return t ? Number(t) : (e => L.includes(e.toLowerCase()))(e) ? 0 : 1
    }

    function I(e, {plugins: t}) {
        function n(t, n) {
            return RegExp(u(t), "m" + (e.case_insensitive ? "i" : "") + (n ? "g" : ""))
        }

        class s {
            constructor() {
                this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0
            }

            addRule(e, t) {
                t.position = this.position++, this.matchIndexes[this.matchAt] = t, this.regexes.push([t, e]),
                    this.matchAt += (e => RegExp(e.toString() + "|").exec("").length - 1)(e) + 1
            }

            compile() {
                0 === this.regexes.length && (this.exec = () => null)
                ;const e = this.regexes.map((e => e[1]));
                this.matcherRe = n(((e, t = "|") => {
                    const n = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
                    let s = 0, r = ""
                    ;
                    for (let a = 0; a < e.length; a++) {
                        s += 1;
                        const i = s;
                        let o = u(e[a])
                        ;
                        for (a > 0 && (r += t), r += "("; o.length > 0;) {
                            const e = n.exec(o);
                            if (null == e) {
                                r += o;
                                break
                            }
                            r += o.substring(0, e.index),
                                o = o.substring(e.index + e[0].length), "\\" === e[0][0] && e[1] ? r += "\\" + (Number(e[1]) + i) : (r += e[0],
                            "(" === e[0] && s++)
                        }
                        r += ")"
                    }
                    return r
                })(e), !0), this.lastIndex = 0
            }

            exec(e) {
                this.matcherRe.lastIndex = this.lastIndex;
                const t = this.matcherRe.exec(e)
                ;
                if (!t) return null
                    ;
                const n = t.findIndex(((e, t) => t > 0 && void 0 !== e)), s = this.matchIndexes[n]
                ;
                return t.splice(0, n), Object.assign(t, s)
            }
        }

        class r {
            constructor() {
                this.rules = [], this.multiRegexes = [],
                    this.count = 0, this.lastIndex = 0, this.regexIndex = 0
            }

            getMatcher(e) {
                if (this.multiRegexes[e]) return this.multiRegexes[e];
                const t = new s
                ;
                return this.rules.slice(e).forEach((([e, n]) => t.addRule(e, n))),
                    t.compile(), this.multiRegexes[e] = t, t
            }

            resumingScanAtSamePosition() {
                return 0 !== this.regexIndex
            }

            considerAll() {
                this.regexIndex = 0
            }

            addRule(e, t) {
                this.rules.push([e, t]), "begin" === t.type && this.count++
            }

            exec(e) {
                const t = this.getMatcher(this.regexIndex);
                t.lastIndex = this.lastIndex
                ;let n = t.exec(e)
                ;
                if (this.resumingScanAtSamePosition()) if (n && n.index === this.lastIndex) ; else {
                    const t = this.getMatcher(0);
                    t.lastIndex = this.lastIndex + 1, n = t.exec(e)
                }
                return n && (this.regexIndex += n.position + 1,
                this.regexIndex === this.count && this.considerAll()), n
            }
        }

        if (e.compilerExtensions || (e.compilerExtensions = []),
        e.contains && e.contains.includes("self")) throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
            ;
        return e.classNameAliases = a(e.classNameAliases || {}), function t(s, i) {
            const o = s
            ;
            if (s.compiled) return o
                ;
            [O].forEach((e => e(s, i))), e.compilerExtensions.forEach((e => e(s, i))),
                s.__beforeBegin = null, [k, M, A].forEach((e => e(s, i))), s.compiled = !0;
            let l = null
            ;
            if ("object" == typeof s.keywords && (l = s.keywords.$pattern,
                delete s.keywords.$pattern), s.keywords && (s.keywords = ((e, t) => {
                const n = {}
                ;
                return "string" == typeof e ? s("keyword", e) : Object.keys(e).forEach((t => {
                    s(t, e[t])
                })), n;

                function s(e, s) {
                    t && (s = s.toLowerCase()), s.split(" ").forEach((t => {
                        const s = t.split("|");
                        n[s[0]] = [e, B(s[0], s[1])]
                    }))
                }
            })(s.keywords, e.case_insensitive)),
            s.lexemes && l) throw Error("ERR: Prefer `keywords.$pattern` to `mode.lexemes`, BOTH are not allowed. (see mode reference) ")
                ;
            return l = l || s.lexemes || /\w+/,
                o.keywordPatternRe = n(l, !0), i && (s.begin || (s.begin = /\B|\b/),
                o.beginRe = n(s.begin), s.endSameAsBegin && (s.end = s.begin),
            s.end || s.endsWithParent || (s.end = /\B|\b/),
            s.end && (o.endRe = n(s.end)), o.terminatorEnd = u(s.end) || "",
            s.endsWithParent && i.terminatorEnd && (o.terminatorEnd += (s.end ? "|" : "") + i.terminatorEnd)),
            s.illegal && (o.illegalRe = n(s.illegal)),
            s.contains || (s.contains = []), s.contains = [].concat(...s.contains.map((e => (e => (e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map((t => a(e, {
                variants: null
            }, t)))), e.cachedVariants ? e.cachedVariants : T(e) ? a(e, {
                starts: e.starts ? a(e.starts) : null
            }) : Object.isFrozen(e) ? a(e) : e))("self" === e ? s : e)))), s.contains.forEach((e => {
                t(e, o)
            })), s.starts && t(s.starts, i), o.matcher = (e => {
                const t = new r
                ;
                return e.contains.forEach((e => t.addRule(e.begin, {
                    rule: e, type: "begin"
                }))), e.terminatorEnd && t.addRule(e.terminatorEnd, {
                    type: "end"
                }), e.illegal && t.addRule(e.illegal, {type: "illegal"}), t
            })(o), o
        }(e)
    }

    function T(e) {
        return !!e && (e.endsWithParent || T(e.starts))
    }

    function j(e) {
        const t = {
            props: ["language", "code", "autodetect"], data: () => ({
                detectedLanguage: "",
                unknownLanguage: !1
            }), computed: {
                className() {
                    return this.unknownLanguage ? "" : "hljs " + this.detectedLanguage
                }, highlighted() {
                    if (!this.autoDetect && !e.getLanguage(this.language)) return console.warn(`The language "${this.language}" you specified could not be found.`),
                        this.unknownLanguage = !0, r(this.code);
                    let t = {}
                    ;
                    return this.autoDetect ? (t = e.highlightAuto(this.code),
                        this.detectedLanguage = t.language) : (t = e.highlight(this.language, this.code, this.ignoreIllegals),
                        this.detectedLanguage = this.language), t.value
                }, autoDetect() {
                    return !(this.language && (e = this.autodetect, !e && "" !== e));
                    var e
                },
                ignoreIllegals: () => !0
            }, render(e) {
                return e("pre", {}, [e("code", {
                    class: this.className, domProps: {innerHTML: this.highlighted}
                })])
            }
        };
        return {
            Component: t, VuePlugin: {
                install(e) {
                    e.component("highlightjs", t)
                }
            }
        }
    }

    const S = {
        "after:highlightBlock": ({block: e, result: t, text: n}) => {
            const s = D(e)
            ;
            if (!s.length) return;
            const a = document.createElement("div")
            ;a.innerHTML = t.value, t.value = ((e, t, n) => {
                let s = 0, a = "";
                const i = [];

                function o() {
                    return e.length && t.length ? e[0].offset !== t[0].offset ? e[0].offset < t[0].offset ? e : t : "start" === t[0].event ? e : t : e.length ? e : t
                }

                function l(e) {
                    a += "<" + P(e) + [].map.call(e.attributes, (function (e) {
                        return " " + e.nodeName + '="' + r(e.value) + '"'
                    })).join("") + ">"
                }

                function c(e) {
                    a += "</" + P(e) + ">"
                }

                function u(e) {
                    ("start" === e.event ? l : c)(e.node)
                }

                for (; e.length || t.length;) {
                    let t = o()
                    ;
                    if (a += r(n.substring(s, t[0].offset)), s = t[0].offset, t === e) {
                        i.reverse().forEach(c)
                        ;
                        do {
                            u(t.splice(0, 1)[0]), t = o()
                        } while (t === e && t.length && t[0].offset === s)
                            ;
                        i.reverse().forEach(l)
                    } else "start" === t[0].event ? i.push(t[0].node) : i.pop(), u(t.splice(0, 1)[0])
                }
                return a + r(n.substr(s))
            })(s, D(a), n)
        }
    };

    function P(e) {
        return e.nodeName.toLowerCase()
    }

    function D(e) {
        const t = [];
        return function e(n, s) {
            for (let r = n.firstChild; r; r = r.nextSibling) 3 === r.nodeType ? s += r.nodeValue.length : 1 === r.nodeType && (t.push({
                event: "start", offset: s, node: r
            }), s = e(r, s), P(r).match(/br|hr|img|input/) || t.push({
                event: "stop", offset: s, node: r
            }));
            return s
        }(e, 0), t
    }

    const C = e => {
            console.error(e)
        }, H = (e, ...t) => {
            console.log("WARN: " + e, ...t)
        }, $ = (e, t) => {
            console.log(`Deprecated as of ${e}. ${t}`)
        }, U = r, z = a, K = Symbol("nomatch")
    ;
    return (e => {
        const n = Object.create(null), r = Object.create(null), a = [];
        let i = !0
        ;const o = /(^(<[^>]+>|\t|)+|\n)/gm,
            l = "Could not find the language '{}', did you forget to load/include a language module?", u = {
                disableAutodetect: !0, name: "Plain text", contains: []
            };
        let g = {
            noHighlightRe: /^(no-?highlight)$/i,
            languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-",
            tabReplace: null, useBR: !1, languages: null, __emitter: c
        };

        function d(e) {
            return g.noHighlightRe.test(e)
        }

        function h(e, t, n, s) {
            const r = {code: t, language: e}
            ;_("before:highlight", r);
            const a = r.result ? r.result : f(r.language, r.code, n, s)
            ;
            return a.code = r.code, _("after:highlight", a), a
        }

        function f(e, t, r, o) {
            const c = t
            ;

            function u(e, t) {
                const n = w.case_insensitive ? t[0].toLowerCase() : t[0]
                ;
                return Object.prototype.hasOwnProperty.call(e.keywords, n) && e.keywords[n]
            }

            function d() {
                null != _.subLanguage ? (() => {
                    if ("" === O) return;
                    let e = null
                    ;
                    if ("string" == typeof _.subLanguage) {
                        if (!n[_.subLanguage]) return void M.addText(O)
                            ;
                        e = f(_.subLanguage, O, !0, k[_.subLanguage]), k[_.subLanguage] = e.top
                    } else e = p(O, _.subLanguage.length ? _.subLanguage : null)
                    ;
                    _.relevance > 0 && (A += e.relevance), M.addSublanguage(e.emitter, e.language)
                })() : (() => {
                    if (!_.keywords) return void M.addText(O);
                    let e = 0
                    ;_.keywordPatternRe.lastIndex = 0;
                    let t = _.keywordPatternRe.exec(O), n = "";
                    for (; t;) {
                        n += O.substring(e, t.index);
                        const s = u(_, t);
                        if (s) {
                            const [e, r] = s
                            ;M.addText(n), n = "", A += r;
                            const a = w.classNameAliases[e] || e;
                            M.addKeyword(t[0], a)
                        } else n += t[0];
                        e = _.keywordPatternRe.lastIndex, t = _.keywordPatternRe.exec(O)
                    }
                    n += O.substr(e), M.addText(n)
                })(), O = ""
            }

            function h(e) {
                return e.className && M.openNode(w.classNameAliases[e.className] || e.className),
                    _ = Object.create(e, {parent: {value: _}}), _
            }

            function m(e, t, n) {
                let r = ((e, t) => {
                    const n = e && e.exec(t);
                    return n && 0 === n.index
                })(e.endRe, n);
                if (r) {
                    if (e["on:end"]) {
                        const n = new s(e);
                        e["on:end"](t, n), n.ignore && (r = !1)
                    }
                    if (r) {
                        for (; e.endsParent && e.parent;) e = e.parent;
                        return e
                    }
                }
                if (e.endsWithParent) return m(e.parent, t, n)
            }

            function b(e) {
                return 0 === _.matcher.regexIndex ? (O += e[0], 1) : (T = !0, 0)
            }

            function x(e) {
                const t = e[0], n = c.substr(e.index), s = m(_, e, n);
                if (!s) return K;
                const r = _
                ;r.skip ? O += t : (r.returnEnd || r.excludeEnd || (O += t), d(), r.excludeEnd && (O = t));
                do {
                    _.className && M.closeNode(), _.skip || _.subLanguage || (A += _.relevance), _ = _.parent
                } while (_ !== s.parent)
                    ;
                return s.starts && (s.endSameAsBegin && (s.starts.endRe = s.endRe),
                    h(s.starts)), r.returnEnd ? 0 : t.length
            }

            let E = {};

            function v(t, n) {
                const a = n && n[0]
                ;
                if (O += t, null == a) return d(), 0
                    ;
                if ("begin" === E.type && "end" === n.type && E.index === n.index && "" === a) {
                    if (O += c.slice(n.index, n.index + 1), !i) {
                        const t = Error("0 width match regex")
                        ;
                        throw t.languageName = e, t.badRule = E.rule, t
                    }
                    return 1
                }
                if (E = n, "begin" === n.type) return function (e) {
                    const t = e[0], n = e.rule, r = new s(n), a = [n.__beforeBegin, n["on:begin"]]
                    ;
                    for (const n of a) if (n && (n(e, r), r.ignore)) return b(t)
                        ;
                    return n && n.endSameAsBegin && (n.endRe = RegExp(t.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"), "m")),
                        n.skip ? O += t : (n.excludeBegin && (O += t),
                            d(), n.returnBegin || n.excludeBegin || (O = t)), h(n), n.returnBegin ? 0 : t.length
                }(n)
                    ;
                if ("illegal" === n.type && !r) {
                    const e = Error('Illegal lexeme "' + a + '" for mode "' + (_.className || "<unnamed>") + '"')
                    ;
                    throw e.mode = _, e
                }
                if ("end" === n.type) {
                    const e = x(n);
                    if (e !== K) return e
                }
                if ("illegal" === n.type && "" === a) return 1
                    ;
                if (B > 1e5 && B > 3 * n.index) throw Error("potential infinite loop, way more iterations than matches")
                    ;
                return O += a, a.length
            }

            const w = N(e)
            ;
            if (!w) throw C(l.replace("{}", e)), Error('Unknown language: "' + e + '"')
                ;
            const R = I(w, {plugins: a});
            let y = "", _ = o || R;
            const k = {}, M = new g.__emitter(g);
            (() => {
                const e = [];
                for (let t = _; t !== w; t = t.parent) t.className && e.unshift(t.className)
                ;
                e.forEach((e => M.openNode(e)))
            })();
            let O = "", A = 0, L = 0, B = 0, T = !1;
            try {
                for (_.matcher.considerAll(); ;) {
                    B++, T ? T = !1 : _.matcher.considerAll(), _.matcher.lastIndex = L
                    ;const e = _.matcher.exec(c);
                    if (!e) break;
                    const t = v(c.substring(L, e.index), e)
                    ;L = e.index + t
                }
                return v(c.substr(L)), M.closeAllNodes(), M.finalize(), y = M.toHTML(), {
                    relevance: A, value: y, language: e, illegal: !1, emitter: M, top: _
                }
            } catch (t) {
                if (t.message && t.message.includes("Illegal")) return {
                    illegal: !0, illegalBy: {
                        msg: t.message, context: c.slice(L - 100, L + 100), mode: t.mode
                    }, sofar: y, relevance: 0,
                    value: U(c), emitter: M
                };
                if (i) return {
                    illegal: !1, relevance: 0, value: U(c), emitter: M,
                    language: e, top: _, errorRaised: t
                };
                throw t
            }
        }

        function p(e, t) {
            t = t || g.languages || Object.keys(n);
            const s = (e => {
                    const t = {
                            relevance: 0,
                            emitter: new g.__emitter(g), value: U(e), illegal: !1, top: u
                        }
                    ;
                    return t.emitter.addText(e), t
                })(e), r = t.filter(N).filter(R).map((t => f(t, e, !1)))
            ;r.unshift(s);
            const a = r.sort(((e, t) => {
                    if (e.relevance !== t.relevance) return t.relevance - e.relevance
                        ;
                    if (e.language && t.language) {
                        if (N(e.language).supersetOf === t.language) return 1
                            ;
                        if (N(t.language).supersetOf === e.language) return -1
                    }
                    return 0
                })), [i, o] = a, l = i
            ;
            return l.second_best = o, l
        }

        const m = {
                "before:highlightBlock": ({block: e}) => {
                    g.useBR && (e.innerHTML = e.innerHTML.replace(/\n/g, "").replace(/<br[ /]*>/g, "\n"))
                }, "after:highlightBlock": ({result: e}) => {
                    g.useBR && (e.value = e.value.replace(/\n/g, "<br>"))
                }
            }, b = /^(<[^>]+>|\t)+/gm, x = {
                "after:highlightBlock": ({result: e}) => {
                    g.tabReplace && (e.value = e.value.replace(b, (e => e.replace(/\t/g, g.tabReplace))))
                }
            }
        ;

        function E(e) {
            let t = null;
            const n = (e => {
                    let t = e.className + " "
                    ;t += e.parentNode ? e.parentNode.className : "";
                    const n = g.languageDetectRe.exec(t)
                    ;
                    if (n) {
                        const t = N(n[1])
                        ;
                        return t || (H(l.replace("{}", n[1])), H("Falling back to no-highlight mode for this block.", e)),
                            t ? n[1] : "no-highlight"
                    }
                    return t.split(/\s+/).find((e => d(e) || N(e)))
                })(e)
            ;
            if (d(n)) return;
            _("before:highlightBlock", {block: e, language: n}), t = e
            ;const s = t.textContent, a = n ? h(n, s, !0) : p(s);
            _("after:highlightBlock", {
                block: e,
                result: a, text: s
            }), e.innerHTML = a.value, ((e, t, n) => {
                const s = t ? r[t] : n
                ;e.classList.add("hljs"), s && e.classList.add(s)
            })(e, n, a.language), e.result = {
                language: a.language, re: a.relevance, relavance: a.relevance
            }, a.second_best && (e.second_best = {
                language: a.second_best.language,
                re: a.second_best.relevance, relavance: a.second_best.relevance
            })
        }

        const v = () => {
                v.called || (v.called = !0, document.querySelectorAll("pre code").forEach(E))
            }
        ;

        function N(e) {
            return e = (e || "").toLowerCase(), n[e] || n[r[e]]
        }

        function w(e, {languageName: t}) {
            "string" == typeof e && (e = [e]), e.forEach((e => {
                r[e] = t
            }))
        }

        function R(e) {
            const t = N(e);
            return t && !t.disableAutodetect
        }

        function _(e, t) {
            const n = e;
            a.forEach((e => {
                e[n] && e[n](t)
            }))
        }

        Object.assign(e, {
            highlight: h,
            highlightAuto: p, fixMarkup: e => {
                return $("10.2.0", "fixMarkup will be removed entirely in v11.0"),
                    $("10.2.0", "Please see https://github.com/highlightjs/highlight.js/issues/2534"),
                    t = e,
                    g.tabReplace || g.useBR ? t.replace(o, (e => "\n" === e ? g.useBR ? "<br>" : e : g.tabReplace ? e.replace(/\t/g, g.tabReplace) : e)) : t
                    ;
                var t
            }, highlightBlock: E, configure: e => {
                e.useBR && ($("10.3.0", "'useBR' will be removed entirely in v11.0"),
                    $("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559")),
                    g = z(g, e)
            }, initHighlighting: v, initHighlightingOnLoad: () => {
                window.addEventListener("DOMContentLoaded", v, !1)
            }, registerLanguage: (t, s) => {
                let r = null;
                try {
                    r = s(e)
                } catch (e) {
                    if (C("Language definition for '{}' could not be registered.".replace("{}", t)),
                        !i) throw e;
                    C(e), r = u
                }
                r.name || (r.name = t), n[t] = r, r.rawDefinition = s.bind(null, e), r.aliases && w(r.aliases, {
                    languageName: t
                })
            }, listLanguages: () => Object.keys(n), getLanguage: N,
            registerAliases: w, requireLanguage: e => {
                $("10.4.0", "requireLanguage will be removed entirely in v11."),
                    $("10.4.0", "Please see https://github.com/highlightjs/highlight.js/pull/2844")
                ;const t = N(e);
                if (t) return t
                    ;
                throw Error("The '{}' language is required, but not loaded.".replace("{}", e))
            },
            autoDetection: R, inherit: z, addPlugin: e => {
                a.push(e)
            }, vuePlugin: j(e).VuePlugin
        }), e.debugMode = () => {
            i = !1
        }, e.safeMode = () => {
            i = !0
        }, e.versionString = "10.5.0"
        ;
        for (const e in y) "object" == typeof y[e] && t(y[e])
        ;
        return Object.assign(e, y), e.addPlugin(m), e.addPlugin(S), e.addPlugin(x), e
    })({})
}();
"object" == typeof exports && "undefined" != typeof module && (module.exports = hljs);
hljs.registerLanguage("bash", (() => {
    "use strict";

    function e(...e) {
        return e.map((e => {
            return (s = e) ? "string" == typeof s ? s : s.source : null;
            var s
        })).join("")
    }

    return s => {
        const n = {}, t = {
            begin: /\$\{/, end: /\}/, contains: ["self", {
                begin: /:-/, contains: [n]
            }]
        };
        Object.assign(n, {
            className: "variable", variants: [{
                begin: e(/\$[\w\d#@][\w\d_]*/, "(?![\\w\\d])(?![$])")
            }, t]
        });
        const a = {
            className: "subst", begin: /\$\(/, end: /\)/, contains: [s.BACKSLASH_ESCAPE]
        }, i = {
            begin: /<<-?\s*(?=\w+)/, starts: {
                contains: [s.END_SAME_AS_BEGIN({
                    begin: /(\w+)/,
                    end: /(\w+)/, className: "string"
                })]
            }
        }, c = {
            className: "string", begin: /"/, end: /"/,
            contains: [s.BACKSLASH_ESCAPE, n, a]
        };
        a.contains.push(c);
        const o = {
            begin: /\$\(\(/,
            end: /\)\)/, contains: [{begin: /\d+#[0-9a-f]+/, className: "number"}, s.NUMBER_MODE, n]
        }, r = s.SHEBANG({
            binary: "(fish|bash|zsh|sh|csh|ksh|tcsh|dash|scsh)", relevance: 10
        }), l = {
            className: "function", begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/, returnBegin: !0,
            contains: [s.inherit(s.TITLE_MODE, {begin: /\w[\w\d_]*/})], relevance: 0
        };
        return {
            name: "Bash", aliases: ["sh", "zsh"], keywords: {
                $pattern: /\b[a-z._-]+\b/,
                keyword: "if then else elif fi for while in do done case esac function",
                literal: "true false",
                built_in: "break cd continue eval exec exit export getopts hash pwd readonly return shift test times trap umask unset alias bind builtin caller command declare echo enable help let local logout mapfile printf read readarray source type typeset ulimit unalias set shopt autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate fc fg float functions getcap getln history integer jobs kill limit log noglob popd print pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp"
            }, contains: [r, s.SHEBANG(), l, o, s.HASH_COMMENT_MODE, i, c, {
                className: "", begin: /\\"/
            }, {className: "string", begin: /'/, end: /'/}, n]
        }
    }
})());
hljs.registerLanguage("xml", (() => {
    "use strict";

    function e(e) {
        return e ? "string" == typeof e ? e : e.source : null
    }

    function n(e) {
        return a("(?=", e, ")")
    }

    function a(...n) {
        return n.map((n => e(n))).join("")
    }

    function s(...n) {
        return "(" + n.map((n => e(n))).join("|") + ")"
    }

    return e => {
        const t = a(/[A-Z_]/, a("(", /[A-Z0-9_.-]+:/, ")?"), /[A-Z0-9_.-]*/), i = {
            className: "symbol", begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/
        }, r = {
            begin: /\s/,
            contains: [{className: "meta-keyword", begin: /#?[a-z_][a-z1-9_-]+/, illegal: /\n/}]
        }, c = e.inherit(r, {begin: /\(/, end: /\)/}), l = e.inherit(e.APOS_STRING_MODE, {
            className: "meta-string"
        }), g = e.inherit(e.QUOTE_STRING_MODE, {
            className: "meta-string"
        }), m = {
            endsWithParent: !0, illegal: /</, relevance: 0,
            contains: [{className: "attr", begin: /[A-Za-z0-9._:-]+/, relevance: 0}, {
                begin: /=\s*/,
                relevance: 0, contains: [{
                    className: "string", endsParent: !0, variants: [{
                        begin: /"/,
                        end: /"/, contains: [i]
                    }, {begin: /'/, end: /'/, contains: [i]}, {begin: /[^\s"'=<>`]+/}]
                }]
            }]
        };
        return {
            name: "HTML, XML",
            aliases: ["html", "xhtml", "rss", "atom", "xjb", "xsd", "xsl", "plist", "wsf", "svg"],
            case_insensitive: !0, contains: [{
                className: "meta", begin: /<![a-z]/, end: />/,
                relevance: 10, contains: [r, g, l, c, {
                    begin: /\[/, end: /\]/, contains: [{
                        className: "meta",
                        begin: /<![a-z]/, end: />/, contains: [r, c, g, l]
                    }]
                }]
            }, e.COMMENT(/<!--/, /-->/, {
                relevance: 10
            }), {begin: /<!\[CDATA\[/, end: /\]\]>/, relevance: 10}, i, {
                className: "meta", begin: /<\?xml/, end: /\?>/, relevance: 10
            }, {
                className: "tag",
                begin: /<style(?=\s|>)/, end: />/, keywords: {name: "style"}, contains: [m], starts: {
                    end: /<\/style>/, returnEnd: !0, subLanguage: ["css", "xml"]
                }
            }, {
                className: "tag",
                begin: /<script(?=\s|>)/, end: />/, keywords: {name: "script"}, contains: [m], starts: {
                    end: /<\/script>/, returnEnd: !0, subLanguage: ["javascript", "handlebars", "xml"]
                }
            }, {
                className: "tag", begin: /<>|<\/>/
            }, {
                className: "tag",
                begin: a(/</, n(a(t, s(/\/>/, />/, /\s/)))), end: /\/?>/, contains: [{
                    className: "name",
                    begin: t, relevance: 0, starts: m
                }]
            }, {
                className: "tag", begin: a(/<\//, n(a(t, />/))),
                contains: [{className: "name", begin: t, relevance: 0}, {begin: />/, relevance: 0}]
            }]
        }
    }
})());
hljs.registerLanguage("markdown", (() => {
    "use strict";

    function n(...n) {
        return n.map((n => {
            return (e = n) ? "string" == typeof e ? e : e.source : null;
            var e
        })).join("")
    }

    return e => {
        const a = {
            begin: /<\/?[A-Za-z_]/, end: ">",
            subLanguage: "xml", relevance: 0
        }, i = {
            variants: [{
                begin: /\[.+?\]\[.*?\]/, relevance: 0
            }, {
                begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
                relevance: 2
            }, {
                begin: n(/\[.+?\]\(/, /[A-Za-z][A-Za-z0-9+.-]*/, /:\/\/.*?\)/),
                relevance: 2
            }, {begin: /\[.+?\]\([./?&#].*?\)/, relevance: 1}, {
                begin: /\[.+?\]\(.*?\)/, relevance: 0
            }], returnBegin: !0, contains: [{
                className: "string", relevance: 0, begin: "\\[", end: "\\]", excludeBegin: !0,
                returnEnd: !0
            }, {
                className: "link", relevance: 0, begin: "\\]\\(", end: "\\)",
                excludeBegin: !0, excludeEnd: !0
            }, {
                className: "symbol", relevance: 0, begin: "\\]\\[",
                end: "\\]", excludeBegin: !0, excludeEnd: !0
            }]
        }, s = {
            className: "strong", contains: [],
            variants: [{begin: /_{2}/, end: /_{2}/}, {begin: /\*{2}/, end: /\*{2}/}]
        }, c = {
            className: "emphasis", contains: [], variants: [{begin: /\*(?!\*)/, end: /\*/}, {
                begin: /_(?!_)/, end: /_/, relevance: 0
            }]
        };
        s.contains.push(c), c.contains.push(s)
        ;let t = [a, i]
        ;
        return s.contains = s.contains.concat(t), c.contains = c.contains.concat(t),
            t = t.concat(s, c), {
            name: "Markdown", aliases: ["md", "mkdown", "mkd"], contains: [{
                className: "section", variants: [{begin: "^#{1,6}", end: "$", contains: t}, {
                    begin: "(?=^.+?\\n[=-]{2,}$)", contains: [{begin: "^[=-]*$"}, {
                        begin: "^", end: "\\n",
                        contains: t
                    }]
                }]
            }, a, {
                className: "bullet", begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
                end: "\\s+", excludeEnd: !0
            }, s, c, {
                className: "quote", begin: "^>\\s+", contains: t,
                end: "$"
            }, {
                className: "code", variants: [{begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*"}, {
                    begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*"
                }, {begin: "```", end: "```+[ ]*$"}, {
                    begin: "~~~", end: "~~~+[ ]*$"
                }, {begin: "`.+?`"}, {
                    begin: "(?=^( {4}|\\t))",
                    contains: [{begin: "^( {4}|\\t)", end: "(\\n)$"}], relevance: 0
                }]
            }, {
                begin: "^[-\\*]{3,}", end: "$"
            }, i, {
                begin: /^\[[^\n]+\]:/, returnBegin: !0, contains: [{
                    className: "symbol", begin: /\[/, end: /\]/, excludeBegin: !0, excludeEnd: !0
                }, {
                    className: "link", begin: /:\s*/, end: /$/, excludeBegin: !0
                }]
            }]
        }
    }
})());
hljs.registerLanguage("ini", (() => {
    "use strict";

    function e(e) {
        return e ? "string" == typeof e ? e : e.source : null
    }

    function n(...n) {
        return n.map((n => e(n))).join("")
    }

    return s => {
        const a = {
            className: "number",
            relevance: 0, variants: [{begin: /([+-]+)?[\d]+_[\d_]+/}, {begin: s.NUMBER_RE}]
        }, i = s.COMMENT();
        i.variants = [{begin: /;/, end: /$/}, {begin: /#/, end: /$/}];
        const t = {
                className: "variable", variants: [{begin: /\$[\w\d"][\w\d_]*/}, {
                    begin: /\$\{(.*?)\}/
                }]
            }, r = {className: "literal", begin: /\bon|off|true|false|yes|no\b/}, l = {
                className: "string", contains: [s.BACKSLASH_ESCAPE], variants: [{
                    begin: "'''",
                    end: "'''", relevance: 10
                }, {begin: '"""', end: '"""', relevance: 10}, {
                    begin: '"', end: '"'
                }, {begin: "'", end: "'"}]
            }, c = {
                begin: /\[/, end: /\]/, contains: [i, r, t, l, a, "self"],
                relevance: 0
            }, g = "(" + [/[A-Za-z0-9_-]+/, /"(\\"|[^"])*"/, /'[^']*'/].map((n => e(n))).join("|") + ")"
        ;
        return {
            name: "TOML, also INI", aliases: ["toml"], case_insensitive: !0, illegal: /\S/,
            contains: [i, {className: "section", begin: /\[+/, end: /\]+/}, {
                begin: n(g, "(\\s*\\.\\s*", g, ")*", n("(?=", /\s*=\s*[^#\s]/, ")")), className: "attr",
                starts: {end: /$/, contains: [i, c, r, t, l, a]}
            }]
        }
    }
})());
hljs.registerLanguage("css", (() => {
    "use strict";
    return e => {
        var n = "[a-zA-Z-][a-zA-Z0-9_-]*", a = {
            begin: /([*]\s?)?(?:[A-Z_.\-\\]+|--[a-zA-Z0-9_-]+)\s*(\/\*\*\/)?:/,
            returnBegin: !0, end: ";", endsWithParent: !0, contains: [{
                className: "attribute",
                begin: /\S/, end: ":", excludeEnd: !0, starts: {
                    endsWithParent: !0, excludeEnd: !0,
                    contains: [{
                        begin: /[\w-]+\(/, returnBegin: !0, contains: [{
                            className: "built_in",
                            begin: /[\w-]+/
                        }, {
                            begin: /\(/, end: /\)/,
                            contains: [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, e.CSS_NUMBER_MODE]
                        }]
                    }, e.CSS_NUMBER_MODE, e.QUOTE_STRING_MODE, e.APOS_STRING_MODE, e.C_BLOCK_COMMENT_MODE, {
                        className: "number", begin: "#[0-9A-Fa-f]+"
                    }, {className: "meta", begin: "!important"}]
                }
            }]
        };
        return {
            name: "CSS", case_insensitive: !0, illegal: /[=|'\$]/,
            contains: [e.C_BLOCK_COMMENT_MODE, {
                className: "selector-id",
                begin: /#[A-Za-z0-9_-]+/
            }, {className: "selector-class", begin: "\\." + n}, {
                className: "selector-attr", begin: /\[/, end: /\]/, illegal: "$",
                contains: [e.APOS_STRING_MODE, e.QUOTE_STRING_MODE]
            }, {
                className: "selector-pseudo",
                begin: /:(:)?[a-zA-Z0-9_+()"'.-]+/
            }, {
                begin: "@(page|font-face)",
                lexemes: "@[a-z-]+", keywords: "@page @font-face"
            }, {
                begin: "@", end: "[{;]",
                illegal: /:/, returnBegin: !0, contains: [{
                    className: "keyword",
                    begin: /@-?\w[\w]*(-\w+)*/
                }, {
                    begin: /\s/, endsWithParent: !0, excludeEnd: !0,
                    relevance: 0, keywords: "and or not only", contains: [{
                        begin: /[a-z-]+:/,
                        className: "attribute"
                    }, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, e.CSS_NUMBER_MODE]
                }]
            }, {className: "selector-tag", begin: n, relevance: 0}, {
                begin: /\{/, end: /\}/,
                illegal: /\S/, contains: [e.C_BLOCK_COMMENT_MODE, {begin: /;/}, a]
            }]
        }
    }
})());
hljs.registerLanguage("json", (() => {
    "use strict";
    return n => {
        const e = {
            literal: "true false null"
        }, i = [n.C_LINE_COMMENT_MODE, n.C_BLOCK_COMMENT_MODE], a = [n.QUOTE_STRING_MODE, n.C_NUMBER_MODE], l = {
            end: ",", endsWithParent: !0, excludeEnd: !0, contains: a, keywords: e
        }, t = {
            begin: /\{/,
            end: /\}/, contains: [{
                className: "attr", begin: /"/, end: /"/,
                contains: [n.BACKSLASH_ESCAPE], illegal: "\\n"
            }, n.inherit(l, {
                begin: /:/
            })].concat(i), illegal: "\\S"
        }, s = {
            begin: "\\[", end: "\\]", contains: [n.inherit(l)],
            illegal: "\\S"
        };
        return a.push(t, s), i.forEach((n => {
            a.push(n)
        })), {
            name: "JSON",
            contains: a, keywords: e, illegal: "\\S"
        }
    }
})());
hljs.registerLanguage("java", (() => {
    "use strict"
    ;var e = "\\.([0-9](_*[0-9])*)", n = "[0-9a-fA-F](_*[0-9a-fA-F])*", a = {
        className: "number", variants: [{
            begin: `(\\b([0-9](_*[0-9])*)((${e})|\\.)?|(${e}))[eE][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, {begin: `\\b([0-9](_*[0-9])*)((${e})[fFdD]?\\b|\\.([fFdD]\\b)?)`}, {
            begin: `(${e})[fFdD]?\\b`
        }, {begin: "\\b([0-9](_*[0-9])*)[fFdD]\\b"}, {
            begin: `\\b0[xX]((${n})\\.?|(${n})?\\.(${n}))[pP][+-]?([0-9](_*[0-9])*)[fFdD]?\\b`
        }, {begin: "\\b(0|[1-9](_*[0-9])*)[lL]?\\b"}, {begin: `\\b0[xX](${n})[lL]?\\b`}, {
            begin: "\\b0(_*[0-7])*[lL]?\\b"
        }, {begin: "\\b0[bB][01](_*[01])*[lL]?\\b"}],
        relevance: 0
    };
    return e => {
        var n = "false synchronized int abstract float private char boolean var static null if const for true while long strictfp finally protected import native final void enum else break transient catch instanceof byte super volatile case assert short package default double public try this switch continue throws protected public private module requires exports do",
            s = {
                className: "meta", begin: "@[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*",
                contains: [{begin: /\(/, end: /\)/, contains: ["self"]}]
            };
        const r = a;
        return {
            name: "Java", aliases: ["jsp"], keywords: n, illegal: /<\/|#/,
            contains: [e.COMMENT("/\\*\\*", "\\*/", {
                relevance: 0, contains: [{
                    begin: /\w+@/,
                    relevance: 0
                }, {className: "doctag", begin: "@[A-Za-z]+"}]
            }), {
                begin: /import java\.[a-z]+\./, keywords: "import", relevance: 2
            }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, {
                className: "class", beginKeywords: "class interface enum", end: /[{;=]/,
                excludeEnd: !0, keywords: "class interface enum", illegal: /[:"\[\]]/, contains: [{
                    beginKeywords: "extends implements"
                }, e.UNDERSCORE_TITLE_MODE]
            }, {
                beginKeywords: "new throw return else", relevance: 0
            }, {
                className: "class",
                begin: "record\\s+" + e.UNDERSCORE_IDENT_RE + "\\s*\\(", returnBegin: !0, excludeEnd: !0,
                end: /[{;=]/, keywords: n, contains: [{beginKeywords: "record"}, {
                    begin: e.UNDERSCORE_IDENT_RE + "\\s*\\(", returnBegin: !0, relevance: 0,
                    contains: [e.UNDERSCORE_TITLE_MODE]
                }, {
                    className: "params", begin: /\(/, end: /\)/,
                    keywords: n, relevance: 0, contains: [e.C_BLOCK_COMMENT_MODE]
                }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, {
                className: "function",
                begin: "([\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*(<[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*(\\s*,\\s*[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*)*>)?\\s+)+" + e.UNDERSCORE_IDENT_RE + "\\s*\\(",
                returnBegin: !0, end: /[{;=]/, excludeEnd: !0, keywords: n, contains: [{
                    begin: e.UNDERSCORE_IDENT_RE + "\\s*\\(", returnBegin: !0, relevance: 0,
                    contains: [e.UNDERSCORE_TITLE_MODE]
                }, {
                    className: "params", begin: /\(/, end: /\)/,
                    keywords: n, relevance: 0,
                    contains: [s, e.APOS_STRING_MODE, e.QUOTE_STRING_MODE, r, e.C_BLOCK_COMMENT_MODE]
                }, e.C_LINE_COMMENT_MODE, e.C_BLOCK_COMMENT_MODE]
            }, r, s]
        }
    }
})());
hljs.registerLanguage("javascript", (() => {
    "use strict"
    ;const e = "[A-Za-z$_][0-9A-Za-z$_]*",
        n = ["as", "in", "of", "if", "for", "while", "finally", "var", "new", "function", "do", "return", "void", "else", "break", "catch", "instanceof", "with", "throw", "case", "default", "try", "switch", "continue", "typeof", "delete", "let", "yield", "const", "class", "debugger", "async", "await", "static", "import", "from", "export", "extends"],
        a = ["true", "false", "null", "undefined", "NaN", "Infinity"],
        s = [].concat(["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"], ["arguments", "this", "super", "console", "window", "document", "localStorage", "module", "global"], ["Intl", "DataView", "Number", "Math", "Date", "String", "RegExp", "Object", "Function", "Boolean", "Error", "Symbol", "Set", "Map", "WeakSet", "WeakMap", "Proxy", "Reflect", "JSON", "Promise", "Float64Array", "Int16Array", "Int32Array", "Int8Array", "Uint16Array", "Uint32Array", "Float32Array", "Array", "Uint8Array", "Uint8ClampedArray", "ArrayBuffer"], ["EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"])
    ;

    function r(e) {
        return i("(?=", e, ")")
    }

    function i(...e) {
        return e.map((e => {
            return (n = e) ? "string" == typeof n ? n : n.source : null;
            var n
        })).join("")
    }

    return t => {
        const c = e, o = {
                begin: /<[A-Za-z0-9\\._:-]+/, end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
                isTrulyOpeningTag: (e, n) => {
                    const a = e[0].length + e.index, s = e.input[a]
                    ;"<" !== s ? ">" === s && (((e, {after: n}) => {
                        const a = "</" + e[0].slice(1)
                        ;
                        return -1 !== e.input.indexOf(a, n)
                    })(e, {
                        after: a
                    }) || n.ignoreMatch()) : n.ignoreMatch()
                }
            }, l = {
                $pattern: e, keyword: n.join(" "),
                literal: a.join(" "), built_in: s.join(" ")
            }, b = "\\.([0-9](_?[0-9])*)", g = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*", d = {
                className: "number", variants: [{
                    begin: `(\\b(${g})((${b})|\\.)?|(${b}))[eE][+-]?([0-9](_?[0-9])*)\\b`
                }, {
                    begin: `\\b(${g})\\b((${b})\\b|\\.)?|(${b})\\b`
                }, {
                    begin: "\\b(0|[1-9](_?[0-9])*)n\\b"
                }, {
                    begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"
                }, {
                    begin: "\\b0[bB][0-1](_?[0-1])*n?\\b"
                }, {begin: "\\b0[oO][0-7](_?[0-7])*n?\\b"}, {
                    begin: "\\b0[0-7]+n?\\b"
                }], relevance: 0
            }, E = {
                className: "subst", begin: "\\$\\{",
                end: "\\}", keywords: l, contains: []
            }, u = {
                begin: "html`", end: "", starts: {
                    end: "`",
                    returnEnd: !1, contains: [t.BACKSLASH_ESCAPE, E], subLanguage: "xml"
                }
            }, _ = {
                begin: "css`", end: "", starts: {
                    end: "`", returnEnd: !1,
                    contains: [t.BACKSLASH_ESCAPE, E], subLanguage: "css"
                }
            }, m = {
                className: "string",
                begin: "`", end: "`", contains: [t.BACKSLASH_ESCAPE, E]
            }, N = {
                className: "comment",
                variants: [t.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
                    relevance: 0, contains: [{
                        className: "doctag", begin: "@[A-Za-z]+", contains: [{
                            className: "type", begin: "\\{",
                            end: "\\}", relevance: 0
                        }, {
                            className: "variable", begin: c + "(?=\\s*(-)|$)",
                            endsParent: !0, relevance: 0
                        }, {begin: /(?=[^\n])\s/, relevance: 0}]
                    }]
                }), t.C_BLOCK_COMMENT_MODE, t.C_LINE_COMMENT_MODE]
            }, y = [t.APOS_STRING_MODE, t.QUOTE_STRING_MODE, u, _, m, d, t.REGEXP_MODE]
        ;E.contains = y.concat({
            begin: /\{/, end: /\}/, keywords: l, contains: ["self"].concat(y)
        });
        const f = [].concat(N, E.contains), A = f.concat([{
            begin: /\(/, end: /\)/, keywords: l,
            contains: ["self"].concat(f)
        }]), p = {
            className: "params", begin: /\(/, end: /\)/,
            excludeBegin: !0, excludeEnd: !0, keywords: l, contains: A
        };
        return {
            name: "Javascript",
            aliases: ["js", "jsx", "mjs", "cjs"], keywords: l, exports: {PARAMS_CONTAINS: A},
            illegal: /#(?![$_A-z])/, contains: [t.SHEBANG({
                label: "shebang", binary: "node",
                relevance: 5
            }), {
                label: "use_strict", className: "meta", relevance: 10,
                begin: /^\s*['"]use (strict|asm)['"]/
            }, t.APOS_STRING_MODE, t.QUOTE_STRING_MODE, u, _, m, N, d, {
                begin: i(/[{,\n]\s*/, r(i(/(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/, c + "\\s*:"))),
                relevance: 0, contains: [{className: "attr", begin: c + r("\\s*:"), relevance: 0}]
            }, {
                begin: "(" + t.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
                keywords: "return throw case", contains: [N, t.REGEXP_MODE, {
                    className: "function",
                    begin: "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + t.UNDERSCORE_IDENT_RE + ")\\s*=>",
                    returnBegin: !0, end: "\\s*=>", contains: [{
                        className: "params", variants: [{
                            begin: t.UNDERSCORE_IDENT_RE, relevance: 0
                        }, {
                            className: null, begin: /\(\s*\)/, skip: !0
                        }, {begin: /\(/, end: /\)/, excludeBegin: !0, excludeEnd: !0, keywords: l, contains: A}]
                    }]
                }, {begin: /,/, relevance: 0}, {className: "", begin: /\s/, end: /\s*/, skip: !0}, {
                    variants: [{begin: "<>", end: "</>"}, {
                        begin: o.begin, "on:begin": o.isTrulyOpeningTag,
                        end: o.end
                    }], subLanguage: "xml", contains: [{
                        begin: o.begin, end: o.end, skip: !0,
                        contains: ["self"]
                    }]
                }], relevance: 0
            }, {
                className: "function",
                beginKeywords: "function", end: /[{;]/, excludeEnd: !0, keywords: l,
                contains: ["self", t.inherit(t.TITLE_MODE, {begin: c}), p], illegal: /%/
            }, {
                beginKeywords: "while if switch catch for"
            }, {
                className: "function",
                begin: t.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
                returnBegin: !0, contains: [p, t.inherit(t.TITLE_MODE, {begin: c})]
            }, {
                variants: [{
                    begin: "\\." + c
                }, {begin: "\\$" + c}], relevance: 0
            }, {
                className: "class",
                beginKeywords: "class", end: /[{;=]/, excludeEnd: !0, illegal: /[:"[\]]/, contains: [{
                    beginKeywords: "extends"
                }, t.UNDERSCORE_TITLE_MODE]
            }, {
                begin: /\b(?=constructor)/,
                end: /[{;]/, excludeEnd: !0, contains: [t.inherit(t.TITLE_MODE, {begin: c}), "self", p]
            }, {
                begin: "(get|set)\\s+(?=" + c + "\\()", end: /\{/, keywords: "get set",
                contains: [t.inherit(t.TITLE_MODE, {begin: c}), {begin: /\(\)/}, p]
            }, {begin: /\$[(.]/}]
        }
    }
})());
hljs.registerLanguage("ruby", (() => {
    "use strict";

    function e(...e) {
        return e.map((e => {
            return (n = e) ? "string" == typeof n ? n : n.source : null;
            var n
        })).join("")
    }

    return n => {
        var a, i = "([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)", s = {
            keyword: "and then defined module in return redo if BEGIN retry end for self when next until do begin unless END rescue else break undef not super class case require yield alias while ensure elsif or include attr_reader attr_writer attr_accessor __FILE__",
            built_in: "proc lambda", literal: "true false nil"
        }, r = {
            className: "doctag",
            begin: "@[A-Za-z]+"
        }, b = {begin: "#<", end: ">"}, t = [n.COMMENT("#", "$", {
            contains: [r]
        }), n.COMMENT("^=begin", "^=end", {
            contains: [r], relevance: 10
        }), n.COMMENT("^__END__", "\\n$")], c = {
            className: "subst", begin: /#\{/, end: /\}/,
            keywords: s
        }, d = {
            className: "string", contains: [n.BACKSLASH_ESCAPE, c], variants: [{
                begin: /'/, end: /'/
            }, {begin: /"/, end: /"/}, {begin: /`/, end: /`/}, {
                begin: /%[qQwWx]?\(/,
                end: /\)/
            }, {begin: /%[qQwWx]?\[/, end: /\]/}, {begin: /%[qQwWx]?\{/, end: /\}/}, {
                begin: /%[qQwWx]?</, end: />/
            }, {begin: /%[qQwWx]?\//, end: /\//}, {
                begin: /%[qQwWx]?%/,
                end: /%/
            }, {begin: /%[qQwWx]?-/, end: /-/}, {begin: /%[qQwWx]?\|/, end: /\|/}, {
                begin: /\B\?(\\\d{1,3}|\\x[A-Fa-f0-9]{1,2}|\\u[A-Fa-f0-9]{4}|\\?\S)\b/
            }, {
                begin: /<<[-~]?'?(\w+)\n(?:[^\n]*\n)*?\s*\1\b/, returnBegin: !0, contains: [{
                    begin: /<<[-~]?'?/
                }, n.END_SAME_AS_BEGIN({
                    begin: /(\w+)/, end: /(\w+)/,
                    contains: [n.BACKSLASH_ESCAPE, c]
                })]
            }]
        }, g = "[0-9](_?[0-9])*", l = {
            className: "number",
            relevance: 0, variants: [{
                begin: `\\b([1-9](_?[0-9])*|0)(\\.(${g}))?([eE][+-]?(${g})|r)?i?\\b`
            }, {
                begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b"
            }, {
                begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b"
            }, {begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b"}, {
                begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"
            }, {
                begin: "\\b0(_?[0-7])+r?i?\\b"
            }]
        }, o = {
            className: "params", begin: "\\(", end: "\\)",
            endsParent: !0, keywords: s
        }, _ = [d, {
            className: "class", beginKeywords: "class module",
            end: "$|;", illegal: /=/, contains: [n.inherit(n.TITLE_MODE, {
                begin: "[A-Za-z_]\\w*(::\\w+)*(\\?|!)?"
            }), {
                begin: "<\\s*", contains: [{
                    begin: "(" + n.IDENT_RE + "::)?" + n.IDENT_RE
                }]
            }].concat(t)
        }, {
            className: "function",
            begin: e(/def\s*/, (a = i + "\\s*(\\(|;|$)", e("(?=", a, ")"))), keywords: "def", end: "$|;",
            contains: [n.inherit(n.TITLE_MODE, {begin: i}), o].concat(t)
        }, {
            begin: n.IDENT_RE + "::"
        }, {className: "symbol", begin: n.UNDERSCORE_IDENT_RE + "(!|\\?)?:", relevance: 0}, {
            className: "symbol", begin: ":(?!\\s)", contains: [d, {begin: i}], relevance: 0
        }, l, {
            className: "variable",
            begin: "(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"
        }, {
            className: "params", begin: /\|/, end: /\|/, relevance: 0, keywords: s
        }, {
            begin: "(" + n.RE_STARTERS_RE + "|unless)\\s*", keywords: "unless", contains: [{
                className: "regexp", contains: [n.BACKSLASH_ESCAPE, c], illegal: /\n/, variants: [{
                    begin: "/", end: "/[a-z]*"
                }, {begin: /%r\{/, end: /\}[a-z]*/}, {
                    begin: "%r\\(",
                    end: "\\)[a-z]*"
                }, {begin: "%r!", end: "![a-z]*"}, {begin: "%r\\[", end: "\\][a-z]*"}]
            }].concat(b, t), relevance: 0
        }].concat(b, t);
        c.contains = _, o.contains = _;
        var E = [{
            begin: /^\s*=>/, starts: {end: "$", contains: _}
        }, {
            className: "meta",
            begin: "^([>?]>|[\\w#]+\\(\\w+\\):\\d+:\\d+>|(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>)(?=[ ])",
            starts: {end: "$", contains: _}
        }];
        return t.unshift(b), {
            name: "Ruby",
            aliases: ["rb", "gemspec", "podspec", "thor", "irb"], keywords: s, illegal: /\/\*/,
            contains: [n.SHEBANG({binary: "ruby"})].concat(E).concat(t).concat(_)
        }
    }
})());
hljs.registerLanguage("yaml", (() => {
    "use strict";
    return e => {
        var n = "true false yes no null", a = "[\\w#;/?:@&=+$,.~*'()[\\]]+", s = {
                className: "string", relevance: 0, variants: [{begin: /'/, end: /'/}, {
                    begin: /"/, end: /"/
                }, {begin: /\S+/}], contains: [e.BACKSLASH_ESCAPE, {
                    className: "template-variable",
                    variants: [{begin: /\{\{/, end: /\}\}/}, {begin: /%\{/, end: /\}/}]
                }]
            }, i = e.inherit(s, {
                variants: [{begin: /'/, end: /'/}, {begin: /"/, end: /"/}, {begin: /[^\s,{}[\]]+/}]
            }), l = {
                end: ",", endsWithParent: !0, excludeEnd: !0, contains: [], keywords: n, relevance: 0
            }, t = {
                begin: /\{/, end: /\}/, contains: [l], illegal: "\\n", relevance: 0
            }, g = {
                begin: "\\[",
                end: "\\]", contains: [l], illegal: "\\n", relevance: 0
            }, b = [{
                className: "attr",
                variants: [{begin: "\\w[\\w :\\/.-]*:(?=[ \t]|$)"}, {
                    begin: '"\\w[\\w :\\/.-]*":(?=[ \t]|$)'
                }, {
                    begin: "'\\w[\\w :\\/.-]*':(?=[ \t]|$)"
                }]
            }, {className: "meta", begin: "^---\\s*$", relevance: 10}, {
                className: "string",
                begin: "[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"
            }, {
                begin: "<%[%=-]?", end: "[%-]?%>", subLanguage: "ruby", excludeBegin: !0, excludeEnd: !0,
                relevance: 0
            }, {className: "type", begin: "!\\w+!" + a}, {
                className: "type",
                begin: "!<" + a + ">"
            }, {className: "type", begin: "!" + a}, {
                className: "type", begin: "!!" + a
            }, {className: "meta", begin: "&" + e.UNDERSCORE_IDENT_RE + "$"}, {
                className: "meta",
                begin: "\\*" + e.UNDERSCORE_IDENT_RE + "$"
            }, {
                className: "bullet", begin: "-(?=[ ]|$)",
                relevance: 0
            }, e.HASH_COMMENT_MODE, {beginKeywords: n, keywords: {literal: n}}, {
                className: "number",
                begin: "\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"
            }, {className: "number", begin: e.C_NUMBER_RE + "\\b", relevance: 0}, t, g, s], r = [...b]
        ;
        return r.pop(), r.push(i), l.contains = r, {
            name: "YAML", case_insensitive: !0,
            aliases: ["yml", "YAML"], contains: b
        }
    }
})());
hljs.registerLanguage("sql", (() => {
    "use strict";

    function e(e) {
        return e ? "string" == typeof e ? e : e.source : null
    }

    function r(...r) {
        return r.map((r => e(r))).join("")
    }

    function t(...r) {
        return "(" + r.map((r => e(r))).join("|") + ")"
    }

    return e => {
        const n = e.COMMENT("--", "$"), a = ["true", "false", "unknown"],
            i = ["bigint", "binary", "blob", "boolean", "char", "character", "clob", "date", "dec", "decfloat", "decimal", "float", "int", "integer", "interval", "nchar", "nclob", "national", "numeric", "real", "row", "smallint", "time", "timestamp", "varchar", "varying", "varbinary"],
            s = ["abs", "acos", "array_agg", "asin", "atan", "avg", "cast", "ceil", "ceiling", "coalesce", "corr", "cos", "cosh", "count", "covar_pop", "covar_samp", "cume_dist", "dense_rank", "deref", "element", "exp", "extract", "first_value", "floor", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "last_value", "lead", "listagg", "ln", "log", "log10", "lower", "max", "min", "mod", "nth_value", "ntile", "nullif", "percent_rank", "percentile_cont", "percentile_disc", "position", "position_regex", "power", "rank", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "row_number", "sin", "sinh", "sqrt", "stddev_pop", "stddev_samp", "substring", "substring_regex", "sum", "tan", "tanh", "translate", "translate_regex", "treat", "trim", "trim_array", "unnest", "upper", "value_of", "var_pop", "var_samp", "width_bucket"],
            o = ["create table", "insert into", "primary key", "foreign key", "not null", "alter table", "add constraint", "grouping sets", "on overflow", "character set", "respect nulls", "ignore nulls", "nulls first", "nulls last", "depth first", "breadth first"],
            c = s,
            l = ["abs", "acos", "all", "allocate", "alter", "and", "any", "are", "array", "array_agg", "array_max_cardinality", "as", "asensitive", "asin", "asymmetric", "at", "atan", "atomic", "authorization", "avg", "begin", "begin_frame", "begin_partition", "between", "bigint", "binary", "blob", "boolean", "both", "by", "call", "called", "cardinality", "cascaded", "case", "cast", "ceil", "ceiling", "char", "char_length", "character", "character_length", "check", "classifier", "clob", "close", "coalesce", "collate", "collect", "column", "commit", "condition", "connect", "constraint", "contains", "convert", "copy", "corr", "corresponding", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cube", "cume_dist", "current", "current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_row", "current_schema", "current_time", "current_timestamp", "current_path", "current_role", "current_transform_group_for_type", "current_user", "cursor", "cycle", "date", "day", "deallocate", "dec", "decimal", "decfloat", "declare", "default", "define", "delete", "dense_rank", "deref", "describe", "deterministic", "disconnect", "distinct", "double", "drop", "dynamic", "each", "element", "else", "empty", "end", "end_frame", "end_partition", "end-exec", "equals", "escape", "every", "except", "exec", "execute", "exists", "exp", "external", "extract", "false", "fetch", "filter", "first_value", "float", "floor", "for", "foreign", "frame_row", "free", "from", "full", "function", "fusion", "get", "global", "grant", "group", "grouping", "groups", "having", "hold", "hour", "identity", "in", "indicator", "initial", "inner", "inout", "insensitive", "insert", "int", "integer", "intersect", "intersection", "interval", "into", "is", "join", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "language", "large", "last_value", "lateral", "lead", "leading", "left", "like", "like_regex", "listagg", "ln", "local", "localtime", "localtimestamp", "log", "log10", "lower", "match", "match_number", "match_recognize", "matches", "max", "member", "merge", "method", "min", "minute", "mod", "modifies", "module", "month", "multiset", "national", "natural", "nchar", "nclob", "new", "no", "none", "normalize", "not", "nth_value", "ntile", "null", "nullif", "numeric", "octet_length", "occurrences_regex", "of", "offset", "old", "omit", "on", "one", "only", "open", "or", "order", "out", "outer", "over", "overlaps", "overlay", "parameter", "partition", "pattern", "per", "percent", "percent_rank", "percentile_cont", "percentile_disc", "period", "portion", "position", "position_regex", "power", "precedes", "precision", "prepare", "primary", "procedure", "ptf", "range", "rank", "reads", "real", "recursive", "ref", "references", "referencing", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "release", "result", "return", "returns", "revoke", "right", "rollback", "rollup", "row", "row_number", "rows", "running", "savepoint", "scope", "scroll", "search", "second", "seek", "select", "sensitive", "session_user", "set", "show", "similar", "sin", "sinh", "skip", "smallint", "some", "specific", "specifictype", "sql", "sqlexception", "sqlstate", "sqlwarning", "sqrt", "start", "static", "stddev_pop", "stddev_samp", "submultiset", "subset", "substring", "substring_regex", "succeeds", "sum", "symmetric", "system", "system_time", "system_user", "table", "tablesample", "tan", "tanh", "then", "time", "timestamp", "timezone_hour", "timezone_minute", "to", "trailing", "translate", "translate_regex", "translation", "treat", "trigger", "trim", "trim_array", "true", "truncate", "uescape", "union", "unique", "unknown", "unnest", "update   ", "upper", "user", "using", "value", "values", "value_of", "var_pop", "var_samp", "varbinary", "varchar", "varying", "versioning", "when", "whenever", "where", "width_bucket", "window", "with", "within", "without", "year", "add", "asc", "collation", "desc", "final", "first", "last", "view"].filter((e => !s.includes(e))),
            u = {
                begin: r(/\b/, t(...c), /\s*\(/), keywords: {built_in: c.join(" ")}
            };
        return {
            name: "SQL", case_insensitive: !0, illegal: /[{}]|<\//, keywords: {
                $pattern: /\b[\w\.]+/, keyword: ((e, {exceptions: r, when: t} = {}) => {
                    const n = t
                    ;
                    return r = r || [], e.map((e => e.match(/\|\d+$/) || r.includes(e) ? e : n(e) ? e + "|0" : e))
                })(l, {when: e => e.length < 3}).join(" "), literal: a.join(" "), type: i.join(" "),
                built_in: "current_catalog current_date current_default_transform_group current_path current_role current_schema current_transform_group_for_type current_user session_user system_time system_user current_time localtime current_timestamp localtimestamp"
            }, contains: [{
                begin: t(...o), keywords: {
                    $pattern: /[\w\.]+/,
                    keyword: l.concat(o).join(" "), literal: a.join(" "), type: i.join(" ")
                }
            }, {
                className: "type",
                begin: t("double precision", "large object", "with timezone", "without timezone")
            }, u, {className: "variable", begin: /@[a-z0-9]+/}, {
                className: "string", variants: [{
                    begin: /'/, end: /'/, contains: [{begin: /''/}]
                }]
            }, {
                begin: /"/, end: /"/, contains: [{
                    begin: /""/
                }]
            }, e.C_NUMBER_MODE, e.C_BLOCK_COMMENT_MODE, n, {
                className: "operator",
                begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/, relevance: 0
            }]
        }
    }
})());